const mongoose = require("mongoose");
const { DraftSchema } = require("../DBModel/Draft");
const {
  isAuthorExist,
  addDraftToAuthor,
  deleteDraft,
} = require("./DBcommentApi");
const { addArticle } = require("./ArticleApi");

// 保存草稿，成功返回草稿信息，失败返回null
// 这里的草稿信息不包含draftId
const addDraft = async (authorId, DraftInfo) => {
  try {
    // 使用模型
    const Draft = mongoose.model("Draft", DraftSchema);

    // 先判断作者是否存在
    const author = await isAuthorExist(authorId);

    // 如果作者不存在，则返回null
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    // 创建草稿
    const draft = new Draft({
      title: DraftInfo.title || "", // 标题
      summary: DraftInfo.summary || "", // 摘要
      authorNickName: author.nickname || author.email, // 作者昵称
      authorEmail: author.email, // 作者邮箱
      content: DraftInfo.content || "", // 内容
      createTime: DraftInfo.createTime || new Date(), // 创建时间
    });

    // 保存草稿
    const result = await draft.save();

    // 保存文章失败
    if (!result) {
      return null;
    }

    // 给作者添加草稿
    const addDraftResult = await addDraftToAuthor(authorId, result._id);

    // 保存作者草稿失败
    if (!addDraftResult) {
      return null;
    }

    // 返回草稿信息
    return result;
  } catch (error) {
    console.log("添加草稿失败", error);
    return null;
  }
};

// 获取草稿信息，成功返回草稿信息，失败返回null
const getDraftInfo = async (authorId, draftId) => {
  try {
    // 使用模型
    const Draft = mongoose.model("Draft", DraftSchema);

    // 查询草稿
    const draft = await Draft.findOne({ _id: draftId });

    // 草稿不存在
    if (!draft) {
      console.log("草稿不存在", draftId);
      return null;
    }

    // 查询草稿作者
    const author = await isAuthorExist(authorId);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    console.log("author.drafts", author.drafts);
    console.log("draftId", draftId);

    // 草稿作者不匹配
    if (!author.drafts.includes(draftId)) {
      console.log("草稿作者不匹配", authorId, draftId);
      return null;
    }

    // 返回草稿信息
    return draft;
  } catch (error) {
    console.log("获取草稿信息失败", error);
    return null;
  }
};

// 保存草稿，成功返会更新的信息，失败返回null
const saveDraft = async (authorId, draftId, DraftInfo) => {
  try {
    // 使用模型
    const Draft = mongoose.model("Draft", DraftSchema);

    // 查询草稿通过id
    // const draft = await Draft.findOne({ _id: draftId });
    const draft = await Draft.findById(draftId);

    // 草稿不存在
    if (!draft) {
      console.log("草稿不存在", draftId);
      return null;
    }

    // 查询草稿作者
    const author = await isAuthorExist(authorId);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    // 草稿作者不匹配
    if (!author.drafts.includes(draftId)) {
      console.log("草稿作者不匹配", authorId, draftId);
      return null;
    }

    // 更新草稿
    const result = await Draft.updateOne(
      { _id: draftId },
      {
        $set: {
          title: DraftInfo.title || "无标题", // 标题
          summary: DraftInfo.summary || "无摘要", // 摘要
          content: DraftInfo.content || "无内容", // 内容
          createdTime: new Date(), // 更新时间
        },
      },
      { new: true }
    );

    // 更新草稿失败
    if (!result) {
      console.log("更新草稿失败", draftId);
      return null;
    }

    // 返回草稿信息
    return result;
  } catch (error) {
    console.log("保存草稿失败", error);
    return null;
  }
};

// 保存草稿为文章，成功返回创建好的文章信息，失败返回null
const saveDraftToArticle = async (authorId, draftId, draftInfo) => {
  try {
    // 这里不需要判断作者是否存在，作者是否存在在前面的函数中已经判断过了

    // 删除草稿作者信息
    const deleteDraftResult = deleteDraft(authorId, draftId);

    // 删除草稿作者信息失败
    if (!deleteDraftResult) {
      console.log("删除草稿作者信息失败", authorId, draftId);
      return null;
    }

    // 给作者添加文章
    const addArticleResult = await addArticle(authorId, {
      // draftId: draftId, // 传入草稿id
      title: draftInfo.title,
      summary: draftInfo.summary,
      content: draftInfo.content,
      createTime: draftInfo.createTime || new Date(),
    });

    // 给作者添加文章失败
    if (!addArticleResult) {
      console.log("给作者添加文章失败", authorId, draftId);
      return null;
    }

    // 返回创建好的文章信息
    return addArticleResult;
  } catch (error) {
    console.log("保存草稿为文章失败", error);
    return false;
  }
};

// 获取草稿列表，成功返回草稿列表，失败返回null
const getDraftList = async (authorId) => {
  try {
    // 使用模型
    const Draft = mongoose.model("Draft", DraftSchema);

    // 查询作者
    const author = await isAuthorExist(authorId);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    // 查询草稿列表
    const draftList = author.drafts.map(async (draftId) => {
      const draft = await Draft.findOne({ _id: draftId });
      return draft;
    });

    // 等待草稿列表查询完成
    const result = await Promise.all(draftList);

    // 返回草稿列表
    return result;
  } catch (error) {
    console.log("获取草稿列表失败", error);
    return null;
  }
};

// 导出草稿
module.exports = {
  getDraftList, // 获取草稿列表
  deleteDraft, // 删除草稿
  saveDraft, // 保存草稿
  addDraft, // 添加草稿
  getDraftInfo, // 获取草稿信息
  saveDraftToArticle, // 保存草稿为文章
};
